// Type: System.Linq.Expressions.Expression
// Assembly: System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Assembly location: C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Core.dll

using System;
using System.Collections.Generic;
using System.Reflection;

namespace System.Linq.Expressions
{
    public abstract class Expression
    {
        protected Expression(ExpressionType nodeType, Type type);
        public ExpressionType NodeType { get; }
        public Type Type { get; }
        public override string ToString();
        public static BinaryExpression Add(Expression left, Expression right);
        public static BinaryExpression Add(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AddChecked(Expression left, Expression right);
        public static BinaryExpression AddChecked(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression And(Expression left, Expression right);
        public static BinaryExpression And(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AndAlso(Expression left, Expression right);
        public static BinaryExpression AndAlso(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression ArrayIndex(Expression array, Expression index);
        public static MethodCallExpression ArrayIndex(Expression array, params Expression[] indexes);
        public static MethodCallExpression ArrayIndex(Expression array, IEnumerable<Expression> indexes);
        public static UnaryExpression ArrayLength(Expression array);
        public static MemberAssignment Bind(MemberInfo member, Expression expression);
        public static MemberAssignment Bind(MethodInfo propertyAccessor, Expression expression);
        public static MethodCallExpression Call(MethodInfo method, params Expression[] arguments);
        public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments);

        public static MethodCallExpression Call(Expression instance, MethodInfo method,
                                                IEnumerable<Expression> arguments);

        public static MethodCallExpression Call(Expression instance, MethodInfo method);

        public static MethodCallExpression Call(Expression instance, string methodName, Type[] typeArguments,
                                                params Expression[] arguments);

        public static MethodCallExpression Call(Type type, string methodName, Type[] typeArguments,
                                                params Expression[] arguments);

        public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion);
        public static BinaryExpression Coalesce(Expression left, Expression right);
        public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse);
        public static ConstantExpression Constant(object value);
        public static ConstantExpression Constant(object value, Type type);
        public static UnaryExpression Convert(Expression expression, Type type);
        public static UnaryExpression Convert(Expression expression, Type type, MethodInfo method);
        public static UnaryExpression ConvertChecked(Expression expression, Type type);
        public static UnaryExpression ConvertChecked(Expression expression, Type type, MethodInfo method);
        public static BinaryExpression Divide(Expression left, Expression right);
        public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression Equal(Expression left, Expression right);
        public static BinaryExpression Equal(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression ExclusiveOr(Expression left, Expression right);
        public static BinaryExpression ExclusiveOr(Expression left, Expression right, MethodInfo method);
        public static MemberExpression Field(Expression expression, FieldInfo field);
        public static MemberExpression Field(Expression expression, string fieldName);
        public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right);

        public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right, bool liftToNull,
                                                          MethodInfo method);

        public static BinaryExpression GreaterThan(Expression left, Expression right);
        public static BinaryExpression GreaterThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static InvocationExpression Invoke(Expression expression, params Expression[] arguments);
        public static InvocationExpression Invoke(Expression expression, IEnumerable<Expression> arguments);
        public static Expression<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters);

        public static Expression<TDelegate> Lambda<TDelegate>(Expression body,
                                                              IEnumerable<ParameterExpression> parameters);

        public static LambdaExpression Lambda(Type delegateType, Expression body,
                                              params ParameterExpression[] parameters);

        public static LambdaExpression Lambda(Type delegateType, Expression body,
                                              IEnumerable<ParameterExpression> parameters);

        public static LambdaExpression Lambda(Expression body, params ParameterExpression[] parameters);
        public static Type GetFuncType(params Type[] typeArgs);
        public static Type GetActionType(params Type[] typeArgs);
        public static BinaryExpression LeftShift(Expression left, Expression right);
        public static BinaryExpression LeftShift(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression LessThan(Expression left, Expression right);
        public static BinaryExpression LessThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression LessThanOrEqual(Expression left, Expression right);

        public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull,
                                                       MethodInfo method);

        public static ListInitExpression ListInit(NewExpression newExpression, params Expression[] initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers);

        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod,
                                                  params Expression[] initializers);

        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod,
                                                  IEnumerable<Expression> initializers);

        public static ListInitExpression ListInit(NewExpression newExpression, params ElementInit[] initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<ElementInit> initializers);
        public static ElementInit ElementInit(MethodInfo addMethod, params Expression[] arguments);
        public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable<Expression> arguments);
        public static MemberListBinding ListBind(MemberInfo member, params ElementInit[] initializers);
        public static MemberListBinding ListBind(MemberInfo member, IEnumerable<ElementInit> initializers);
        public static MemberListBinding ListBind(MethodInfo propertyAccessor, params ElementInit[] initializers);
        public static MemberListBinding ListBind(MethodInfo propertyAccessor, IEnumerable<ElementInit> initializers);
        public static MemberInitExpression MemberInit(NewExpression newExpression, params MemberBinding[] bindings);
        public static MemberInitExpression MemberInit(NewExpression newExpression, IEnumerable<MemberBinding> bindings);
        public static MemberMemberBinding MemberBind(MemberInfo member, params MemberBinding[] bindings);
        public static MemberMemberBinding MemberBind(MemberInfo member, IEnumerable<MemberBinding> bindings);
        public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, params MemberBinding[] bindings);
        public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, IEnumerable<MemberBinding> bindings);
        public static BinaryExpression Modulo(Expression left, Expression right);
        public static BinaryExpression Modulo(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression Multiply(Expression left, Expression right);
        public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression MultiplyChecked(Expression left, Expression right);
        public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method);
        public static UnaryExpression UnaryPlus(Expression expression);
        public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method);
        public static UnaryExpression Negate(Expression expression);
        public static UnaryExpression Negate(Expression expression, MethodInfo method);
        public static UnaryExpression NegateChecked(Expression expression);
        public static UnaryExpression NegateChecked(Expression expression, MethodInfo method);
        public static BinaryExpression NotEqual(Expression left, Expression right);
        public static BinaryExpression NotEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static NewExpression New(ConstructorInfo constructor, params Expression[] arguments);
        public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments);

        public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments,
                                        IEnumerable<MemberInfo> members);

        public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments,
                                        params MemberInfo[] members);

        public static NewExpression New(ConstructorInfo constructor);
        public static NewExpression New(Type type);
        public static NewArrayExpression NewArrayBounds(Type type, params Expression[] bounds);
        public static NewArrayExpression NewArrayBounds(Type type, IEnumerable<Expression> bounds);
        public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers);
        public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression> initializers);
        public static UnaryExpression Not(Expression expression);
        public static UnaryExpression Not(Expression expression, MethodInfo method);
        public static BinaryExpression Or(Expression left, Expression right);
        public static BinaryExpression Or(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression OrElse(Expression left, Expression right);
        public static BinaryExpression OrElse(Expression left, Expression right, MethodInfo method);
        public static ParameterExpression Parameter(Type type, string name);
        public static BinaryExpression Power(Expression left, Expression right);
        public static BinaryExpression Power(Expression left, Expression right, MethodInfo method);
        public static MemberExpression Property(Expression expression, PropertyInfo property);
        public static MemberExpression Property(Expression expression, MethodInfo propertyAccessor);
        public static MemberExpression Property(Expression expression, string propertyName);
        public static MemberExpression PropertyOrField(Expression expression, string propertyOrFieldName);
        public static UnaryExpression Quote(Expression expression);
        public static BinaryExpression RightShift(Expression left, Expression right);
        public static BinaryExpression RightShift(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression Subtract(Expression left, Expression right);
        public static BinaryExpression Subtract(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression SubtractChecked(Expression left, Expression right);
        public static BinaryExpression SubtractChecked(Expression left, Expression right, MethodInfo method);
        public static UnaryExpression TypeAs(Expression expression, Type type);
        public static TypeBinaryExpression TypeIs(Expression expression, Type type);
        public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type);

        public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type,
                                                MethodInfo method);

        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right);

        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right,
                                                  bool liftToNull, MethodInfo method);

        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right,
                                                  bool liftToNull, MethodInfo method, LambdaExpression conversion);

        public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member);
    }
}
